import apiClient from '../apiClient';
import {
  TestConnectionRequest,
  TestConnectionResponse,
  GetDatabasesRequest,
  GetDatabasesResponse,
  GetTablesRequest,
  GetTablesResponse,
  GetConnectionsRequest,
  CreateConnectionRequest,
  CreateConnectionResponse,
  UpdateConnectionRequest,
  UpdateConnectionResponse,
  GetConnectionsResponse,
  DeleteConnectionResponse,
  SetDatabaseLimitRequest,
  SetDatabaseLimitResponse,
  GetDatabaseLimitResponse,
  GetTableDataResponse,
  CreateTermResponse,
  UpdateTermResponse,
  DeleteTermResponse,
  GetTermsResponse,
  CreateCaseResponse,
  UpdateCaseResponse,
  DeleteCaseResponse,
  GetCasesResponse,
  SearchTableColumnsRequest,
  SearchTableColumnsResponse,
  UpdateTableRequest,
  UpdateTableResponse,
  UpdateTableStatusRequest,
  UpdateTableStatusResponse,
  GetColumnEnumRequest,
  GetColumnEnumResponse,
  DeleteTableResponse,
  DeleteColumnResponse,
  UpdateColumnZhNameRequest,
  UpdateColumnZhNameResponse,
  TaskIdResponse,
  TaskProgressResponse,
  DeleteTaskProgressResponse,
} from '@/types/nl2sql/type';

// API 前缀配置，方便统一管理
const API_PREFIX = '/openapi/v1/nl2sql/ts/v1';
// const API_PREFIX = '/ts/v1';

export enum Nl2sqlApi {
  // 数据库连接测试接口
  TestConnection = `${API_PREFIX}/datasource/test-connection`,
  // 获取数据库列表接口
  GetDatabases = `${API_PREFIX}/datasource/databases`,
  // 获取表列表接口
  GetTables = `${API_PREFIX}/datasource/tables`,
  // 创建数据库连接接口
  CreateConnection = `${API_PREFIX}/database/connections`,
  // 更新数据库连接接口
  UpdateConnection = `${API_PREFIX}/database/connections`,
  // 获取数据库连接列表接口
  GetConnections = `${API_PREFIX}/database/connections`,
  // 删除数据库连接接口
  DeleteConnection = `${API_PREFIX}/database/connections`,
  // 设置数据库查询限制接口
  SetDatabaseLimit = `${API_PREFIX}/database/connections`,
  // 获取数据库查询限制接口
  GetDatabaseLimit = `${API_PREFIX}/database/connections`,
  // 获取表数据接口
  GetTableData = `${API_PREFIX}/database/connections`,
  // 表列搜索接口
  SearchTableColumns = `${API_PREFIX}/database/table`,
  // 更新表信息接口
  UpdateTable = `${API_PREFIX}/database/table`,
  // 更新数据表状态接口
  UpdateTableStatus = `${API_PREFIX}/database/table_all`,
  // 获取表列枚举值接口
  GetColumnEnum = `${API_PREFIX}/database/table`,
  // 删除表接口
  DeleteTable = `${API_PREFIX}/database/table`,
  // 删除列接口
  DeleteColumn = `${API_PREFIX}/database/table`,
  // 更新列中文名称接口
  UpdateColumnZhName = `${API_PREFIX}/database/table`,
  // 术语管理接口
  CreateTerm = `${API_PREFIX}/knowledge/terms`,
  UpdateTerm = `${API_PREFIX}/knowledge/terms/update`,
  DeleteTerm = `${API_PREFIX}/knowledge/terms/delete`,
  GetTerms = `${API_PREFIX}/knowledge/terms`,
  // 案例管理接口
  CreateCase = `${API_PREFIX}/knowledge/sql`,
  UpdateCase = `${API_PREFIX}/knowledge/sql/update`,
  DeleteCase = `${API_PREFIX}/knowledge/sql/delete`,
  GetCases = `${API_PREFIX}/knowledge/sql`,
  // 创建/更新数据库连接（异步任务-进度版）
  CreateConnectionProgress = `${API_PREFIX}/database/connections-progress`,
  UpdateConnectionProgress = `${API_PREFIX}/database/connections-progress`,
  // 任务进度查询/删除
  TaskProgress = `${API_PREFIX}/database/progress`,
}

/**
 * 测试数据库连接
 * @param data 数据库连接参数
 * @returns 连接测试结果
 */
const testConnection = (data: TestConnectionRequest) =>
  apiClient.post<TestConnectionResponse>({ 
    url: Nl2sqlApi.TestConnection, 
    data 
  });

/**
 * 获取数据库列表
 * @param data 数据库连接参数
 * @returns 数据库列表
 */
const getDatabases = (data: GetDatabasesRequest) =>
  apiClient.post<GetDatabasesResponse>({ 
    url: Nl2sqlApi.GetDatabases, 
    data 
  });

/**
 * 获取表列表
 * @param data 数据库连接参数
 * @returns 表列表
 */
const getTables = (data: GetTablesRequest) =>
  apiClient.post<GetTablesResponse>({ 
    url: Nl2sqlApi.GetTables, 
    data 
  });

/**
 * 创建数据库连接
 * @param data 创建连接参数
 * @returns 创建结果
 */
const createConnection = (data: CreateConnectionRequest) =>
  apiClient.post<CreateConnectionResponse>({ 
    url: Nl2sqlApi.CreateConnection, 
    data 
  });

/**
 * 更新数据库连接
 * @param connectionId 连接ID
 * @param data 更新连接参数
 * @returns 更新结果
 */
const updateConnection = (connectionId: string, data: UpdateConnectionRequest) =>
  apiClient.post<UpdateConnectionResponse>({ 
    url: `${Nl2sqlApi.UpdateConnection}/${connectionId}`, 
    data 
  });

/**
 * 获取数据库连接列表
 * @returns 连接列表
 */
const getConnections = (params: GetConnectionsRequest) =>
  apiClient.get<GetConnectionsResponse>({ 
    url: Nl2sqlApi.GetConnections,
    params
  });

/**
 * 删除数据库连接
 * @param connectionId 连接ID
 * @returns 删除结果
 */
const deleteConnection = (connectionId: string) =>
  apiClient.post<DeleteConnectionResponse>({ 
    url: `${Nl2sqlApi.DeleteConnection}/${connectionId}/delete` 
  });

/**
 * 设置数据库查询限制
 * @param connectionId 连接ID
 * @param data 设置参数
 * @returns 设置结果
 */
const setDatabaseLimit = (connectionId: string, data: SetDatabaseLimitRequest) =>
  apiClient.post<SetDatabaseLimitResponse>({ 
    url: `${Nl2sqlApi.SetDatabaseLimit}/${connectionId}/setting`, 
    data 
  });

/**
 * 获取数据库查询限制
 * @param connectionId 连接ID
 * @returns 查询限制信息
 */
const getDatabaseLimit = (connectionId: string) =>
  apiClient.get<GetDatabaseLimitResponse>({ 
    url: `${Nl2sqlApi.GetDatabaseLimit}/${connectionId}/setting` 
  });

/**
 * 获取表数据
 * @param connectionId 连接ID
 * @param tableName 表名
 * @param limit 限制数量
 * @returns 表数据
 */
const getTableData = (connectionId: string, tableName: string, limit: number = 10) =>
  apiClient.get<GetTableDataResponse>({ 
    url: `${Nl2sqlApi.GetTableData}/${connectionId}/tables/${tableName}/limit/${limit}` 
  });

/**
 * 搜索表列
 * @param tableId 表ID
 * @param data 搜索参数
 * @returns 表列列表
 */
const searchTableColumns = (tableId: string, data: SearchTableColumnsRequest) =>
  apiClient.get<SearchTableColumnsResponse>({ 
    url: `${Nl2sqlApi.SearchTableColumns}/${tableId}/column/search`, 
    params: data 
  });



/**
 * 创建术语
 * @param data 创建术语参数
 * @returns 创建结果
 */
const createTerm = (data: { knowledge_id: string; name: string; description: string }) =>
  apiClient.post<CreateTermResponse>({ 
    url: Nl2sqlApi.CreateTerm, 
    data 
  });

/**
 * 更新术语
 * @param data 更新术语参数
 * @returns 更新结果
 */
const updateTerm = (data: { knowledge_id: string; name: string; description: string; data_id: string }) =>
  apiClient.post<UpdateTermResponse>({ 
    url: Nl2sqlApi.UpdateTerm, 
    data 
  });

/**
 * 删除术语
 * @param data 删除术语参数
 * @returns 删除结果
 */
const deleteTerm = (data: { knowledge_id: string; name: string; description: string; data_id: string }[]) =>
  apiClient.post<DeleteTermResponse>({ 
    url: Nl2sqlApi.DeleteTerm, 
    data 
  });

/**
 * 获取术语列表
 * @param knowledgeId 知识库ID
 * @returns 术语列表
 */
const getTerms = (knowledgeId: string) =>
  apiClient.get<GetTermsResponse>({ 
    url: `${Nl2sqlApi.GetTerms}/${knowledgeId}` 
  });


/**
 * 创建案例
 * @param data 创建案例参数
 * @returns 创建结果
 */
const createCase = (data: { knowledge_id: string; name: string; description: string }) =>
  apiClient.post<CreateCaseResponse>({ 
    url: Nl2sqlApi.CreateCase, 
    data 
  });

/**
 * 更新案例
 * @param data 更新案例参数
 * @returns 更新结果
 */
const updateCase = (data: { knowledge_id: string; name: string; description: string; data_id: string }) =>
  apiClient.post<UpdateCaseResponse>({ 
    url: Nl2sqlApi.UpdateCase, 
    data 
  });

/**
 * 删除案例
 * @param data 删除案例参数
 * @returns 删除结果
 */
const deleteCase = (data: { knowledge_id: string; name: string; description: string; data_id: string }[]) =>
  apiClient.post<DeleteCaseResponse>({ 
    url: Nl2sqlApi.DeleteCase, 
    data 
  });

/**
 * 获取案例列表
 * @param knowledgeId 知识库ID
 * @returns 案例列表
 */
const getCases = (knowledgeId: string) =>
  apiClient.get<GetCasesResponse>({ 
    url: `${Nl2sqlApi.GetCases}/${knowledgeId}` 
  });

/**
 * 更新表信息
 * @param datasetId 数据集ID
 * @param tableId 表ID
 * @param data 更新表信息参数
 * @returns 更新结果
 */
const updateTable = (datasetId: string, tableId: string, data: UpdateTableRequest) =>
  apiClient.post<UpdateTableResponse>({ 
    url: `${Nl2sqlApi.UpdateTable}/${datasetId}/${tableId}`, 
    data 
  });

/**
 * 更新数据表状态
 * @param tableId 表ID
 * @param data 更新表状态参数
 * @returns 更新结果
 */
const updateTableStatus = (tableId: string, data: UpdateTableStatusRequest) =>
  apiClient.post<UpdateTableStatusResponse>({ 
    url: `${Nl2sqlApi.UpdateTableStatus}/${tableId}`, 
    data 
  });

/**
 * 获取表列枚举值
 * @param tableId 表ID
 * @param columnName 列名
 * @param data 请求参数
 * @returns 枚举值列表
 */
const getColumnEnum = (tableId: string, columnName: string, data: GetColumnEnumRequest) =>
  apiClient.post<GetColumnEnumResponse>({ 
    url: `${Nl2sqlApi.GetColumnEnum}/${tableId}/column/${columnName}/enum`,
    data
  });

/**
 * 删除指定的表
 * @param datasetId 数据集ID
 * @param tableId 表ID
 * @returns 删除结果
 */
const deleteTable = (datasetId: string, tableId: string) =>
  apiClient.post<DeleteTableResponse>({ 
    url: `${Nl2sqlApi.DeleteTable}/${datasetId}/${tableId}/delete` 
  });

/**
 * 删除指定的列
 * @param datasetId 数据集ID
 * @param tableId 表ID
 * @param columnName 列名
 * @returns 删除结果
 */
const deleteColumn = (datasetId: string, tableId: string, columnName: string) =>
  apiClient.post<DeleteColumnResponse>({ 
    url: `${Nl2sqlApi.DeleteColumn}/${datasetId}/${tableId}/column/${columnName}` 
  });

/**
 * 更新指定列中文名称
 * @param datasetId 数据集ID
 * @param tableId 表ID
 * @param columnName 列名
 * @param data 更新列中文名称参数
 * @returns 更新结果
 */
const updateColumnZhName = (datasetId: string, tableId: string, columnName: string, data: UpdateColumnZhNameRequest) =>
  apiClient.post<UpdateColumnZhNameResponse>({ 
    url: `${Nl2sqlApi.UpdateColumnZhName}/${datasetId}/${tableId}/column/${columnName}/zh_name`, 
    data 
  });

/**
 * 创建数据库连接（进度版，异步任务）
 * @param data 创建连接参数
 * @returns 任务ID
 */
const createConnectionProgress = (data: CreateConnectionRequest) =>
  apiClient.post<TaskIdResponse>({
    url: Nl2sqlApi.CreateConnectionProgress,
    data,
  });

/**
 * 更新数据库连接（进度版，异步任务）
 * @param connectionId 连接ID
 * @param data 更新连接参数
 * @returns 任务ID
 */
const updateConnectionProgress = (connectionId: string, data: UpdateConnectionRequest) =>
  apiClient.post<TaskIdResponse>({
    url: `${Nl2sqlApi.UpdateConnectionProgress}/${connectionId}`,
    data,
  });

/**
 * 查询任务进度
 * @param taskId 任务ID
 * @returns 任务进度信息
 */
const getTaskProgress = (taskId: string) =>
  apiClient.get<TaskProgressResponse>({
    url: `${Nl2sqlApi.TaskProgress}/${taskId}`
  });

/**
 * 删除任务进度
 * @param taskId 任务ID
 * @returns 删除结果
 */
const deleteTaskProgress = (taskId: string) =>
  apiClient.post<DeleteTaskProgressResponse>({
    url: `${Nl2sqlApi.TaskProgress}/${taskId}/delete`,
  });


export default {
  testConnection,
  getDatabases,
  getTables,
  createConnection,
  updateConnection,
  getConnections,
  deleteConnection,
  setDatabaseLimit,
  getDatabaseLimit,
  getTableData,
  searchTableColumns,
  getColumnEnum,
  updateTable,
  updateTableStatus,
  deleteTable,
  deleteColumn,
  updateColumnZhName,
  createConnectionProgress,
  updateConnectionProgress,
  getTaskProgress,
  deleteTaskProgress,
  createTerm,
  updateTerm,
  deleteTerm,
  getTerms,
  createCase,
  updateCase,
  deleteCase,
  getCases,
};
